// 获取应用实例
const app = getApp();
const api = require('../../utils/api');
const userApi = require('../../utils/api/user');
const request = require('../../utils/request');

// Flask API 地址
const FLASK_API_URL = 'http://127.0.0.1:5000/api/predict'; // 本地开发环境
// const FLASK_API_URL = '您的远程服务器地址'; // 部署环境

Page({
  // 页面的初始数据
  data: {
    formData: {
      Pregnancies: 0,
      Glucose: '',
      BloodPressure: '',
      SkinThickness: '',
      Insulin: '',
      BMI: '',
      DiabetesPedigreeFunction: '',
      Age: ''
    },
    loading: false,
    showResult: false,
    riskLevel: '',
    probability: 0,
    riskDescription: '',
    resultClass: '',
    suggestions: [],
    showFeatureImportance: false,
    featureImportance: [],
    needReset: false,
    userInfo: null,
    sourceInfo: {
      Age: '未填充',
      Pregnancies: '默认值',
      Glucose: '未填充',
      BloodPressure: '未填充',
      BMI: '未填充'
    }
  },

  // 生命周期函数--监听页面加载
  onLoad: function(options) {
    // 引入request模块，确保能够调用getUserProfile函数
    this.request = require('../../utils/request');
    
    // 如果有传递的参数，填充到表单
    if (options.data) {
      try {
        const data = JSON.parse(options.data);
        this.setData({
          formData: {
            ...this.data.formData,
            ...data
          }
        });
      } catch (error) {
        console.error('解析参数失败:', error);
      }
    } else {
      // 重置表单
      this.resetForm();
    }

    // 尝试预填充用户数据
    this.prefillUserData();
  },

  // 生命周期函数--监听页面显示
  onShow: function() {
    // 当从结果页面返回时，重置表单
    if (this.data.needReset) {
      this.resetForm();
      this.setData({ needReset: false });
      // 重新加载预设值
      this.prefillUserData();
    }
  },

  // 预填充用户数据
  async prefillUserData() {
    try {
      wx.showLoading({
        title: '加载数据中...',
        mask: true
      });
      
      // 获取用户基本信息
      let userData = null;
      try {
        // 注意: 使用正确的API调用方式，确保能获取到完整的用户信息
        const userProfileResp = await request.getUserProfile();
        console.log('获取到用户资料API响应:', userProfileResp);
        
        if (userProfileResp && userProfileResp.success) {
          userData = userProfileResp.data;
          console.log('获取到有效的用户信息:', userData);
        } else {
          console.warn('API返回的用户资料无效:', userProfileResp);
          // 尝试使用备用方法获取用户信息
          userData = await userApi.getUserInfo();
          console.log('从备用API获取到用户信息:', userData);
        }
        
        // 添加详细的用户性别信息日志
        if (userData) {
          console.log('用户性别数据:', { 
            gender: userData.gender, 
            genderType: typeof userData.gender,
            genderValue: userData.gender
          });
          
          // 增强性别判断逻辑
          const userGender = userData.gender;
          
          // 增强性别判断条件，确保各种可能的女性标识都能被正确识别
          const isFemale = 
            userGender === 'female' || 
            userGender === '女' || 
            userGender === '女性' ||
            userGender == 2 || // 使用非严格等于兼容数字和字符串
            (typeof userGender === 'string' && userGender.includes('female')) ||
            (typeof userGender === 'string' && userGender.includes('女'));
          
          console.log('性别判断结果:', { isFemale });
          
          // 添加标识到userData对象中
          userData.isFemale = isFemale;
        }
        
        this.setData({ userInfo: userData });
        
        // 检查用户身高体重信息完整性
        if (userData && userData.height && userData.weight) {
          console.log('用户身高体重数据:', { 
            height: userData.height, 
            weight: userData.weight,
            heightType: typeof userData.height,
            weightType: typeof userData.weight
          });
        } else {
          console.log('用户身高体重数据不完整:', userData ? { height: userData.height, weight: userData.weight } : 'userData为空');
        }
      } catch (error) {
        console.error('获取用户信息失败:', error);
      }
      
      // 获取最新的健康数据
      let healthData = null;
      try {
        healthData = await this.fetchLatestHealthData();
        console.log('获取到健康数据:', healthData);
      } catch (error) {
        console.error('获取健康数据失败:', error);
      }
      
      // 更新表单数据
      const newFormData = { ...this.data.formData };
      const sourceInfo = { ...this.data.sourceInfo };
      
      // 处理年龄信息
      if (userData && userData.birthDate) {
        const age = userApi.calculateAge(userData.birthDate);
        if (age > 0) {
          newFormData.Age = age;
          sourceInfo.Age = '个人资料';
        }
      }
      
      // 处理性别和孕次信息
      if (userData) {
        if (userData.isFemale) {
          // 女性用户，孕次默认为0，但可以修改
          if (!newFormData.Pregnancies && newFormData.Pregnancies !== 0) { // 只在未设置时才设置默认值
            newFormData.Pregnancies = 0;
            sourceInfo.Pregnancies = '默认值(可修改)';
          }
          console.log('女性用户孕次设置:', { pregnancies: newFormData.Pregnancies, source: sourceInfo.Pregnancies });
        } else {
          // 男性孕次为0且不可修改
          newFormData.Pregnancies = 0;
          sourceInfo.Pregnancies = '男性用户(固定值)';
          console.log('男性用户孕次设置:', { pregnancies: newFormData.Pregnancies, source: sourceInfo.Pregnancies });
        }
      }
      
      // 处理BMI信息 - 增强从用户信息获取BMI的逻辑
      if (userData && userData.bmi) {
        // 优先直接使用用户资料中的BMI值(如果存在)
        newFormData.BMI = userData.bmi;
        sourceInfo.BMI = '个人资料(BMI)';
        console.log('直接使用用户资料中的BMI:', userData.bmi);
      } else if (userData && userData.height && userData.weight) {
        try {
          // 确保将字符串转换为数值
          const height = parseFloat(String(userData.height).replace(/[^\d.]/g, '')) / 100; // 转换为米
          const weight = parseFloat(String(userData.weight).replace(/[^\d.]/g, '')); 
          
          console.log('BMI计算:', { height, weight });
          
          if (!isNaN(height) && !isNaN(weight) && height > 0) {
            const bmi = (weight / (height * height)).toFixed(1);
            console.log('计算得到的BMI:', bmi);
            newFormData.BMI = bmi;
            sourceInfo.BMI = '个人资料(计算)';
          } else {
            console.log('BMI计算无效 - 身高或体重无效:', { height, weight });
          }
        } catch (error) {
          console.error('BMI计算错误:', error);
        }
      } else if (healthData && healthData.bmi) {
        // 从健康数据获取BMI
        newFormData.BMI = healthData.bmi;
        sourceInfo.BMI = '最新记录';
        console.log('使用健康数据中的BMI:', healthData.bmi);
      } else {
        console.log('未能获取BMI值');
      }
      
      // 处理血糖信息
      if (healthData && healthData.glucose) {
        newFormData.Glucose = healthData.glucose;
        sourceInfo.Glucose = '最新记录';
      }
      
      // 处理血压信息
      if (healthData && healthData.bloodPressure) {
        if (healthData.bloodPressure.diastolic) {
          newFormData.BloodPressure = healthData.bloodPressure.diastolic;
          sourceInfo.BloodPressure = '最新舒张压记录';
        }
      }
      
      // 移除糖尿病谱系函数的默认值设置
      // 注意：不再设置DiabetesPedigreeFunction的默认值，让用户自行填写
      
      // 更新数据
      this.setData({
        formData: newFormData,
        sourceInfo: sourceInfo
      });
      
      wx.hideLoading();
    } catch (error) {
      console.error('预填充用户数据失败:', error);
      wx.hideLoading();
      wx.showToast({
        title: '数据加载失败',
        icon: 'none'
      });
    }
  },

  // 获取最新的健康数据
  async fetchLatestHealthData() {
    try {
      // 获取最近30天的数据范围
      const now = new Date();
      const monthAgo = new Date(now);
      monthAgo.setDate(now.getDate() - 30);
      
      const startDate = monthAgo.toISOString();
      const endDate = now.toISOString();
      
      // 并行获取各种健康数据
      const [glucoseData, bpData, weightData] = await Promise.all([
        // 获取血糖数据
        api.health.getRecords({
          type: 'glucose',
          startDate,
          endDate,
          limit: 5 // 获取最近5条记录以增加命中率
        }),
        
        // 获取血压数据
        api.health.getRecords({
          type: 'bloodpressure',
          startDate,
          endDate,
          limit: 5
        }),
        
        // 获取体重数据
        api.health.getRecords({
          type: 'weight',
          startDate,
          endDate,
          limit: 5
        })
      ]);
      
      // 整合数据
      const healthData = {};
      
      // 处理血糖数据
      if (glucoseData && glucoseData.length > 0) {
        // 尝试获取空腹血糖值(清晨记录)，否则使用最新的记录
        const morningRecord = glucoseData.find(record => {
          const date = new Date(record.timestamp || record.measuredAt);
          const hours = date.getHours();
          return hours >= 6 && hours <= 9; // 早上6点到9点的记录
        });
        
        if (morningRecord) {
          // 将mmol/L单位转换为mg/dL
          const glucoseValue = parseFloat(morningRecord.value);
          healthData.glucose = Math.round(glucoseValue * 18); // mmol/L 转换为 mg/dL (乘以18)
        } else {
          // 将mmol/L单位转换为mg/dL
          const glucoseValue = parseFloat(glucoseData[0].value);
          healthData.glucose = Math.round(glucoseValue * 18); // mmol/L 转换为 mg/dL (乘以18)
        }
        
        console.log('血糖值转换: 原始值(mmol/L)=', 
          morningRecord ? parseFloat(morningRecord.value) : parseFloat(glucoseData[0].value), 
          '转换后(mg/dL)=', healthData.glucose);
      }
      
      // 处理血压数据
      if (bpData && bpData.length > 0) {
        healthData.bloodPressure = {
          systolic: parseInt(bpData[0].systolic),
          diastolic: parseInt(bpData[0].diastolic)
        };
      }
      
      // 处理体重数据
      if (weightData && weightData.length > 0) {
        healthData.weight = parseFloat(weightData[0].value);
        
        // 如果已有用户身高信息，计算BMI
        const userData = this.data.userInfo;
        if (userData && userData.height) {
          const height = parseFloat(userData.height) / 100; // 转换为米
          if (!isNaN(height) && height > 0) {
            healthData.bmi = (healthData.weight / (height * height)).toFixed(1);
          }
        }
      }
      
      return healthData;
    } catch (error) {
      console.error('获取最新健康数据失败:', error);
      return null;
    }
  },

  // 显示数据来源提示
  showSourceInfo: function(e) {
    const field = e.currentTarget.dataset.field;
    const source = this.data.sourceInfo[field] || '未知来源';
    
    wx.showToast({
      title: `${this.getFieldLabel(field)}：${source}`,
      icon: 'none',
      duration: 2000
    });
  },

  // 表单提交处理函数
  submitForm: function(e) {
    // 获取表单数据
    const formData = e.detail.value;
    
    // 表单验证
    if (!this.validateForm(formData)) {
      return;
    }
    
    // 开始加载
    this.setData({ loading: true });
    
    // 调用Flask API预测
    this.predictDiabetesRisk(formData);
  },
  
  // 表单验证
  validateForm: function(formData) {
    // 检查必填字段
    const requiredFields = ['Age', 'Glucose', 'BloodPressure', 'BMI'];
    for (const field of requiredFields) {
      if (!formData[field]) {
        wx.showToast({
          title: `请填写${this.getFieldLabel(field)}`,
          icon: 'none',
          duration: 2000
        });
        return false;
      }
    }
    
    // 转换为数字并进行范围验证
    const numericFields = Object.keys(formData);
    for (const field of numericFields) {
      formData[field] = parseFloat(formData[field]);
      
      // 检查是否为有效数字
      if (isNaN(formData[field])) {
        wx.showToast({
          title: `${this.getFieldLabel(field)}必须是数字`,
          icon: 'none',
          duration: 2000
        });
        return false;
      }
      
      // 根据字段检查范围
      if (!this.validateFieldRange(field, formData[field])) {
        return false;
      }
    }
    
    return true;
  },
  
  // 验证字段范围
  validateFieldRange: function(field, value) {
    let isValid = true;
    let message = '';
    
    switch (field) {
      case 'Age':
        if (value < 0 || value > 120) {
          isValid = false;
          message = '年龄应在0-120之间';
        }
        break;
      case 'Pregnancies':
        if (value < 0 || value > 20) {
          isValid = false;
          message = '孕次应在0-20之间';
        }
        break;
      case 'Glucose':
        if (value < 50 || value > 300) {
          isValid = false;
          message = '血糖值应在50-300之间';
        }
        break;
      case 'BloodPressure':
        if (value < 30 || value > 180) {
          isValid = false;
          message = '血压值应在30-180之间';
        }
        break;
      case 'SkinThickness':
        if (value < 0 || value > 100) {
          isValid = false;
          message = '皮褶厚度应在0-100之间';
        }
        break;
      case 'Insulin':
        if (value < 0 || value > 1000) {
          isValid = false;
          message = '胰岛素值应在0-1000之间';
        }
        break;
      case 'BMI':
        if (value < 10 || value > 70) {
          isValid = false;
          message = 'BMI应在10-70之间';
        }
        break;
      case 'DiabetesPedigreeFunction':
        if (value < 0 || value > 2.5) {
          isValid = false;
          message = '糖尿病谱系函数值应在0-2.5之间';
        }
        break;
    }
    
    if (!isValid) {
      wx.showToast({
        title: message,
        icon: 'none',
        duration: 2000
      });
    }
    
    return isValid;
  },
  
  // 获取字段对应的中文标签
  getFieldLabel: function(field) {
    const fieldLabels = {
      'Age': '年龄',
      'Pregnancies': '孕次',
      'Glucose': '血糖',
      'BloodPressure': '血压',
      'SkinThickness': '皮褶厚度',
      'Insulin': '胰岛素',
      'BMI': 'BMI',
      'DiabetesPedigreeFunction': '糖尿病谱系函数'
    };
    return fieldLabels[field] || field;
  },
  
  // 调用Flask API进行预测
  predictDiabetesRisk: function(formData) {
    // 开始加载
    this.setData({ loading: true });
    
    // 创建请求对象
    wx.request({
      url: FLASK_API_URL,
      method: 'POST',
      header: {
        'content-type': 'application/json'
      },
      data: formData,
      success: (res) => {
        console.log('API响应:', res.data);
        
        // 关闭加载状态
        this.setData({ loading: false });
        
        // 检查API调用是否成功
        if (res.statusCode === 200 && res.data.success) {
          // 导航到结果页面，传递结果数据
          wx.navigateTo({
            url: '/pages/riskAssessment/riskResult?result=' + encodeURIComponent(JSON.stringify(res.data)) + 
                 '&inputData=' + encodeURIComponent(JSON.stringify(formData))
          });
        } else {
          // API调用失败
          wx.showToast({
            title: '预测失败: ' + (res.data.error || '未知错误'),
            icon: 'none',
            duration: 3000
          });
          
          // 尝试使用模拟数据（开发/测试阶段）
          this.simulatePrediction(formData);
        }
      },
      fail: (error) => {
        console.error('API请求失败:', error);
        
        // 关闭加载状态
        this.setData({ loading: false });
        
        // 显示错误消息
        wx.showToast({
          title: '网络请求失败，将使用模拟数据',
          icon: 'none',
          duration: 2000
        });
        
        // 使用模拟数据（开发/测试阶段）
        this.simulatePrediction(formData);
      }
    });
  },
  
  // 模拟预测结果（用于API不可用时）
  simulatePrediction: function(formData) {
    console.log('使用模拟数据');
    
    // 基于输入数据生成随机但相对合理的预测结果
    let probability = 0;
    
    // 血糖高、年龄大、BMI高的风险增加
    if (formData.Glucose > 140) probability += 0.3;
    if (formData.Age > 50) probability += 0.2;
    if (formData.BMI > 30) probability += 0.2;
    
    // 添加一些随机性
    probability += Math.random() * 0.3;
    
    // 确保在0-1之间
    probability = Math.min(Math.max(probability, 0), 1);
    
    // 生成模拟结果
    const result = {
      prediction: probability > 0.5 ? 1 : 0,
      probability: probability,
      risk_level: probability < 0.4 ? '低风险' : probability < 0.7 ? '中风险' : '高风险',
      success: true
    };
    
    // 导航到结果页面
    wx.navigateTo({
      url: '/pages/riskAssessment/riskResult?result=' + encodeURIComponent(JSON.stringify(result)) + 
           '&inputData=' + encodeURIComponent(JSON.stringify(formData))
    });
  },
  
  // 重置表单
  resetForm: function() {
    this.setData({
      formData: {
        Pregnancies: 0,
        Glucose: '',
        BloodPressure: '',
        SkinThickness: '',
        Insulin: '',
        BMI: '',
        DiabetesPedigreeFunction: '',
        Age: ''
      },
      sourceInfo: {
        Age: '未填充',
        Pregnancies: '默认值',
        Glucose: '未填充',
        BloodPressure: '未填充',
        BMI: '未填充'
      }
    });
    
    // 重新获取预设值
    setTimeout(() => {
      this.prefillUserData();
    }, 100);
    
    wx.showToast({
      title: '表单已重置',
      icon: 'success',
      duration: 1500
    });
  },
  
  // 查看历史记录
  viewHistory: function() {
    // 确保关闭任何当前的加载状态
    wx.hideLoading();
    
    console.log('准备跳转到风险评估历史页面...');
    
    // 添加延迟避免连续跳转可能导致的问题
    setTimeout(() => {
      wx.navigateTo({
        url: '/pages/riskAssessment/riskHistory',
        success: function() {
          console.log('成功跳转到风险评估历史页面');
        },
        fail: function(error) {
          console.error('跳转到风险评估历史页面失败:', error);
          wx.showToast({
            title: '无法打开历史记录',
            icon: 'none',
            duration: 2000
          });
        }
      });
    }, 200);
  },
  
  // 返回主页
  goToHomePage: function() {
    wx.switchTab({
      url: '/pages/health/health'
    });
  },
})